#pragma warning(disable:4996)
#include<stdio.h>
#include<string.h>

void yangshijz(int arr[][3], int* px, int* py, int key) {
	// 1 2 3
	// 4 5 6
	// 7 8 9
	int x = 0;
	int y = *py - 1;
	
	while (x < (*py - 1) && y >= 0) {
		//当目前查找的矩阵的最右上角的值小于key的值
		//说明最上面一行已经没有要找的数了 所以行数++ x++
		if (arr[x][y] < key) {
			x++;
		}
		//当目前查找的矩阵的最右上角的值大于key的值
		//说明最右边一列已经没有要找的数了 所以列数-- y--
		else if (arr[x][y] > key) {
			y--;
		}
		//找到传回参数并返回
		else {
			//使用输出型参数传回两个下标
			*px = x;
			*py = y;
			return;
		}
	}

	//程序运行到这里 说明矩阵里找不到要找到数
	//把返回的参数的值设置为-1 表示没找到
	*px = -1;
	*py = -1;
}

//abcdef
//bcdefa
//void leftRound(char* str, int k) {
//	int len = strlen(str);
//	k %= len;
//
//	//旋转k次
//	while (k--) {
//		//把一个字符旋转到末尾
//		char tmp = *str;
//		//从第二个字符开始整体前移一位
//		for (int i = 0; i < len - 1; ++i) {
//			*(str + i) = *(str + i + 1);
//		}
//		//把第一个拿出来的字符放到末尾位置
//		*(str + len - 1) = tmp;
//	}
//}
#include<assert.h>
void reverse(char* left, char* right) {
	assert(left && right);
	while (left < right) {
		char tmp = *left;
		*left = *right;
		*right = tmp;
		left++;
		right--;
	}
}
//方法2
//先逆置0 - k-1位置的字符
//再逆置k - len-1 位置字符
void leftRound(char* str, int k) {
	int len = strlen(str);
	reverse(str, str + k - 1);
	reverse(str + k, str + len - 1);
	reverse(str, str + len - 1);
}

//方法一 
//旋转一个字符判断一次
//int findRound(const char* str1, char* str2) {
//	int len = strlen(str2);
//	int j = len;
//	while (j--) {
//		char tmp = *str2;
//		//从第二个字符开始整体前移一位
//		for (int i = 0; i < len - 1; ++i) {
//			*(str2 + i) = *(str2 + i + 1);
//		}
//		//把第一个拿出来的字符放到末尾位置
//		*(str2 + len - 1) = tmp;
//
//		if (strcmp(str1, str2) == 0) {
//			return 1;
//		}
//	}
//
//	return 0;
//}

//方法2
//给示例字符串后面再追加一个自己本身字符串 然后只需要判断要判断的字符串是不是这个追加后的
//字符串的子串，就能判断是不是旋转后的字符串
int findRound(const char* str1, char* str2) {
	int len1 = strlen(str1);
	int len2 = strlen(str2);
	if (len1 != len2) {
		return 0;
	}

	char tmp[256] = "";
	strcat(tmp, str1);
	strcat(tmp, str1);

	if (strstr(tmp, str2) == NULL) {
		return 0;
	}
	else {
		return 1;
	}
}

void swap(char* s1, char* s2, int type_len) {
	while (type_len--) {
		char tmp = *s1;
		*s1 = *s2;
		*s2 = tmp;
		s1++;
		s2++;
	}
}

int cmp(void* c1, void* c2) {
	return *((int*)c1) - *((int*)c2);
}

void bubble_sort(void* arr, int size, int type_len, int (*cmp)(void* c1, void* c2)) {
	
	for (int i = 0; i < size - 1; ++i) {
		for (int j = 0; j < size - i - 1; ++j) {
			if (cmp((char*)arr + (j * type_len), (char*)arr + (j + 1) * (type_len)) > 0) {
				swap((char*)arr + (j * type_len), (char*)arr + (j + 1) * (type_len), type_len);
			}
		}
	}
}

int main() {
	/*int arr[][3] = { 1,2,3,4,5,6,7,8,9 };
	int key = 0;
	scanf_s("%d", &key);
	int x = 3;
	int y = 3;
	yangshijz(arr, &x, &y, key);

	if (x == -1 && y == -1) {
		printf("没找到");
	}
	else {
		printf("找到了，下标是arr[%d][%d]", x, y);
	}*/

	/*char str[] = "abcdef";
	int k = 0;
	scanf_s("%d", &k);
	leftRound(str, k);
	printf("%s", str);*/
	/*char str1[] = "abcdef";
	char str2[] = "defabc";
	int ret = findRound(str1, str2);
	if (ret == 1) {
		printf("YES\n");
	}
	else {
		printf("NO\n");
	}*/

	int arr[] = { 3,2,5,7,8,1,0,9,4 };     //定义整型数组并初始化
	int sz = sizeof(arr) / sizeof(arr[0]);    //计算数组长度
	int i = 0;
	bubble_sort(arr, sz, sizeof(arr[0]), cmp);    //模拟qsort函数实现冒泡排序
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);                     //排序完后对数组进行打印，验证排序是否成功
	}

	return 0;
}


//void GetMemory(char* p){
//	p = (char*)malloc(100);
//}
//void Test(void){
//	char* str = NULL;
//	GetMemory(str);
//	strcpy(str, "hello world");
//	printf(str);
//}


//char* GetMemory(void){
//	char p[] = "hello world";
//	//return p 返回的是字符数组p的首元素地址
//	return p;
//}
////但是出了这个函数作用域,局部变量p就会被销毁，此时字符数组内的内容已经被销毁
//void Test(void){
//	char* str = NULL;
//	//使用str接收p的值，str指向p指向的空间，但是那个空间已经在函数结束时销毁，此时str是没有那段空间的访问权限的
//	//str就变为了野指针，打印str地址的内容，内容就是随机值
//	str = GetMemory();
//	printf(str);
//}


//void GetMemory(char** p, int num){
//	*p = (char*)malloc(num);
//}
//void Test(void){
//	char* str = NULL;
//	GetMemory(&str, 100);
//	strcpy(str, "hello");
//	printf(str);
//}

void Test(void){
	char* str = (char*)malloc(100);
	strcpy(str, "hello");
	free(str);
	//释放完的空间最好置空，不然就可能会被访问
	if (str != NULL){
		strcpy(str, "world");
		printf(str);
	}
}
